// //  ********************************************************************************
// //  Copyright (C) 2016 Sebastian Kenter. All rights reserved.
// // 
// //  Name    : PhotonServerProject | PhotonServerCommon | RegisterSubServerMessage.cs
// //  Created : 2016 - 04 - 18 08:39
// //  Modified: 2016 - 04 - 18 09:38
// //  ********************************************************************************

#pragma warning disable 1591, 0612, 3021

#region Designer generated code

using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;

namespace PhotonServerCommon.Messages
{
    /// <summary>Holder for reflection information generated from RegisterSubServerMessage.proto</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public static partial class RegisterSubServerMessageReflection
    {
        #region Descriptor

        /// <summary>File descriptor for RegisterSubServerMessage.proto</summary>
        public static pbr::FileDescriptor Descriptor
        {
            get { return descriptor; }
        }

        private static pbr::FileDescriptor descriptor;

        static RegisterSubServerMessageReflection()
        {
            byte[] descriptorData = global::System.Convert.FromBase64String(
                string.Concat(
                    "Ch5SZWdpc3RlclN1YlNlcnZlck1lc3NhZ2UucHJvdG8SG1Bob3RvblNlcnZl",
                    "ckNvbW1vbi5NZXNzYWdlcyIyChhSZWdpc3RlclN1YlNlcnZlclJlcXVlc3QS",
                    "FgoOc2VydmVyX3BlZXJfaWQYASABKAkiMwoZUmVnaXN0ZXJTdWJTZXJ2ZXJS",
                    "ZXNwb25zZRIWCg5zZXJ2ZXJfcGVlcl9pZBgBIAEoCWIGcHJvdG8z"));
            descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
                new pbr::FileDescriptor[] {},
                new pbr::GeneratedCodeInfo(null, new pbr::GeneratedCodeInfo[]
                                                 {
                                                     new pbr::GeneratedCodeInfo(
                                                         typeof (
                                                         global::PhotonServerCommon.Messages.RegisterSubServerRequest),
                                                         global::PhotonServerCommon.Messages.RegisterSubServerRequest
                                                         .Parser, new[] {"ServerPeerId"}, null, null, null),
                                                     new pbr::GeneratedCodeInfo(
                                                         typeof (
                                                         global::PhotonServerCommon.Messages.RegisterSubServerResponse),
                                                         global::PhotonServerCommon.Messages.RegisterSubServerResponse
                                                         .Parser, new[] {"ServerPeerId"}, null, null, null)
                                                 }));
        }

        #endregion
    }

    #region Messages

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class RegisterSubServerRequest : pb::IMessage<RegisterSubServerRequest>
    {
        /// <summary>Field number for the "server_peer_id" field.</summary>
        public const int ServerPeerIdFieldNumber = 1;

        private static readonly pb::MessageParser<RegisterSubServerRequest> _parser =
            new pb::MessageParser<RegisterSubServerRequest>(() => new RegisterSubServerRequest());

        public static pb::MessageParser<RegisterSubServerRequest> Parser
        {
            get { return _parser; }
        }

        public static pbr::MessageDescriptor Descriptor
        {
            get
            {
                return global::PhotonServerCommon.Messages.RegisterSubServerMessageReflection.Descriptor.MessageTypes[0];
            }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public string ServerPeerId
        {
            get { return serverPeerId_; }
            set { serverPeerId_ = pb::Preconditions.CheckNotNull(value, "value"); }
        }

        private string serverPeerId_ = "";

        public RegisterSubServerRequest()
        {
            OnConstruction();
        }

        public RegisterSubServerRequest(RegisterSubServerRequest other) : this()
        {
            serverPeerId_ = other.serverPeerId_;
        }

        partial void OnConstruction();

        public RegisterSubServerRequest Clone()
        {
            return new RegisterSubServerRequest(this);
        }

        public override bool Equals(object other)
        {
            return Equals(other as RegisterSubServerRequest);
        }

        public bool Equals(RegisterSubServerRequest other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (ServerPeerId != other.ServerPeerId) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (ServerPeerId.Length != 0) hash ^= ServerPeerId.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (ServerPeerId.Length != 0)
            {
                output.WriteRawTag(10);
                output.WriteString(ServerPeerId);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (ServerPeerId.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(ServerPeerId);
            }
            return size;
        }

        public void MergeFrom(RegisterSubServerRequest other)
        {
            if (other == null)
            {
                return;
            }
            if (other.ServerPeerId.Length != 0)
            {
                ServerPeerId = other.ServerPeerId;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                    {
                        ServerPeerId = input.ReadString();
                        break;
                    }
                }
            }
        }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    public sealed partial class RegisterSubServerResponse : pb::IMessage<RegisterSubServerResponse>
    {
        /// <summary>Field number for the "server_peer_id" field.</summary>
        public const int ServerPeerIdFieldNumber = 1;

        private static readonly pb::MessageParser<RegisterSubServerResponse> _parser =
            new pb::MessageParser<RegisterSubServerResponse>(() => new RegisterSubServerResponse());

        public static pb::MessageParser<RegisterSubServerResponse> Parser
        {
            get { return _parser; }
        }

        public static pbr::MessageDescriptor Descriptor
        {
            get
            {
                return global::PhotonServerCommon.Messages.RegisterSubServerMessageReflection.Descriptor.MessageTypes[1];
            }
        }

        pbr::MessageDescriptor pb::IMessage.Descriptor
        {
            get { return Descriptor; }
        }

        public string ServerPeerId
        {
            get { return serverPeerId_; }
            set { serverPeerId_ = pb::Preconditions.CheckNotNull(value, "value"); }
        }

        private string serverPeerId_ = "";

        public RegisterSubServerResponse()
        {
            OnConstruction();
        }

        public RegisterSubServerResponse(RegisterSubServerResponse other) : this()
        {
            serverPeerId_ = other.serverPeerId_;
        }

        partial void OnConstruction();

        public RegisterSubServerResponse Clone()
        {
            return new RegisterSubServerResponse(this);
        }

        public override bool Equals(object other)
        {
            return Equals(other as RegisterSubServerResponse);
        }

        public bool Equals(RegisterSubServerResponse other)
        {
            if (ReferenceEquals(other, null))
            {
                return false;
            }
            if (ReferenceEquals(other, this))
            {
                return true;
            }
            if (ServerPeerId != other.ServerPeerId) return false;
            return true;
        }

        public override int GetHashCode()
        {
            int hash = 1;
            if (ServerPeerId.Length != 0) hash ^= ServerPeerId.GetHashCode();
            return hash;
        }

        public override string ToString()
        {
            return pb::JsonFormatter.ToDiagnosticString(this);
        }

        public void WriteTo(pb::CodedOutputStream output)
        {
            if (ServerPeerId.Length != 0)
            {
                output.WriteRawTag(10);
                output.WriteString(ServerPeerId);
            }
        }

        public int CalculateSize()
        {
            int size = 0;
            if (ServerPeerId.Length != 0)
            {
                size += 1 + pb::CodedOutputStream.ComputeStringSize(ServerPeerId);
            }
            return size;
        }

        public void MergeFrom(RegisterSubServerResponse other)
        {
            if (other == null)
            {
                return;
            }
            if (other.ServerPeerId.Length != 0)
            {
                ServerPeerId = other.ServerPeerId;
            }
        }

        public void MergeFrom(pb::CodedInputStream input)
        {
            uint tag;
            while ((tag = input.ReadTag()) != 0)
            {
                switch (tag)
                {
                    default:
                        input.SkipLastField();
                        break;
                    case 10:
                    {
                        ServerPeerId = input.ReadString();
                        break;
                    }
                }
            }
        }
    }

    #endregion
}

#endregion Designer generated code
